home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.1B1 / PInterfaces / OCEStandardMail.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  21.9 KB  |  701 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        OCEStandardMail.p
  3.  
  4.      Contains:    Apple Open Collaboration Environment Standard Mail Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Package:    Universal Interfaces 2.1ß1 in “MPW Prerelease” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT OCEStandardMail;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __OCESTANDARDMAIL__}
  30. {$SETC __OCESTANDARDMAIL__ := 1}
  31.  
  32. {$I+}
  33. {$SETC OCEStandardMailIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __EVENTS__}
  38. {$I Events.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    Quickdraw.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        QuickdrawText.p                                            }
  45. {    OSUtils.p                                                    }
  46. {        Memory.p                                                }
  47.  
  48. {$IFC UNDEFINED __APPLEEVENTS__}
  49. {$I AppleEvents.p}
  50. {$ENDC}
  51. {    Errors.p                                                    }
  52. {    EPPC.p                                                        }
  53. {        AppleTalk.p                                                }
  54. {        Files.p                                                    }
  55. {        PPCToolbox.p                                            }
  56. {        Processes.p                                                }
  57. {    Notification.p                                                }
  58.  
  59. {$IFC UNDEFINED __CONTROLS__}
  60. {$I Controls.p}
  61. {$ENDC}
  62. {    Menus.p                                                        }
  63.  
  64. {$IFC UNDEFINED __DIALOGS__}
  65. {$I Dialogs.p}
  66. {$ENDC}
  67. {    Windows.p                                                    }
  68. {    TextEdit.p                                                    }
  69.  
  70. {$IFC UNDEFINED __FILES__}
  71. {$I Files.p}
  72. {$ENDC}
  73.  
  74. {$IFC UNDEFINED __WINDOWS__}
  75. {$I Windows.p}
  76. {$ENDC}
  77.  
  78. {$IFC UNDEFINED __OCEAUTHDIR__}
  79. {$I OCEAuthDir.p}
  80. {$ENDC}
  81. {    OCE.p                                                        }
  82. {        Aliases.p                                                }
  83. {        Script.p                                                }
  84. {            IntlResources.p                                        }
  85.  
  86. {$IFC UNDEFINED __OCEMAIL__}
  87. {$I OCEMail.p}
  88. {$ENDC}
  89. {    DigitalSignature.p                                            }
  90. {    OCEMessaging.p                                                }
  91.  
  92. {$PUSH}
  93. {$ALIGN MAC68K}
  94. {$LibExport+}
  95.  
  96. CONST
  97.     kSMPVersion                    = 1;
  98.     gestaltSMPMailerVersion        = 'malr';
  99.     gestaltSMPSPSendLetterVersion = 'spsl';
  100.     kSMPNativeFormatName        = 'natv';
  101.  
  102.  
  103. TYPE
  104.     LetterSpec = RECORD
  105.         spec:                    ARRAY [0..2] OF LONGINT;
  106.     END;
  107.  
  108.  
  109. CONST
  110.     typeLetterSpec                = 'lttr';
  111.  
  112. {    Wildcard used for filtering letter types. }
  113.     FilterAnyLetter                = 'ltr*';
  114.     FilterAppleLetterContent    = 'ltc*';
  115.     FilterImageContent            = 'lti*';
  116.  
  117.  
  118. TYPE
  119.     LetterDescriptor = RECORD
  120.         onDisk:                    BOOLEAN;
  121.         filler1:                BOOLEAN;
  122.         CASE INTEGER OF
  123.         0: (
  124.             fileSpec:                    FSSpec;
  125.            );
  126.         1: (
  127.             mailboxSpec:                LetterSpec;
  128.            );
  129.     END;
  130.  
  131. {
  132. SMPPSendAs values.  You may add the following values together to determine how the
  133. file is sent, but you may not set both kSMPSendAsEnclosureMask and kSMPSendFileOnlyMask.  This
  134. will allow you to send the letter as an image so that it will work with fax gateways
  135. and send as an enclosure as well.
  136. }
  137.  
  138. CONST
  139.     kSMPSendAsEnclosureBit        = 0;                            { Appears as letter with enclosures }
  140.     kSMPSendFileOnlyBit            = 1;                            { Appears as a file in mailbox. }
  141.     kSMPSendAsImageBit            = 2;                            { Content imaged in letter }
  142.  
  143. { Values of SMPPSendAs }
  144.     kSMPSendAsEnclosureMask        = 1 * (2**(kSMPSendAsEnclosureBit));
  145.     kSMPSendFileOnlyMask        = 1 * (2**(kSMPSendFileOnlyBit));
  146.     kSMPSendAsImageMask            = 1 * (2**(kSMPSendAsImageBit));
  147.  
  148.     
  149. TYPE
  150.     SMPPSendAs = SignedByte;
  151.  
  152.     SMPDrawImageProcPtr = ProcPtr;  { PROCEDURE SMPDrawImage(refcon: LONGINT; inColor: BOOLEAN); }
  153.     SMPDrawImageUPP = UniversalProcPtr;
  154.  
  155. CONST
  156.     uppSMPDrawImageProcInfo = $000001C0; { PROCEDURE (4 byte param, 1 byte param); }
  157.  
  158. FUNCTION NewSMPDrawImageProc(userRoutine: SMPDrawImageProcPtr): SMPDrawImageUPP;
  159.     {$IFC NOT GENERATINGCFM }
  160.     INLINE $2E9F;
  161.     {$ENDC}
  162.  
  163. PROCEDURE CallSMPDrawImageProc(refcon: LONGINT; inColor: BOOLEAN; userRoutine: SMPDrawImageUPP);
  164.     {$IFC NOT GENERATINGCFM}
  165.     INLINE $205F, $4E90;
  166.     {$ENDC}
  167.  
  168. TYPE
  169.     SMPRecipientDescriptor = RECORD
  170.         next:                    ^SMPRecipientDescriptor;                {  Q-Link. }
  171.         result:                    OSErr;                                    {  result code when using the object. }
  172.         recipient:                ^OCEPackedRecipient;                    {  Pointer to a Packed Address. }
  173.         size:                    LONGINT;                                {  length of recipient in bytes. }
  174.         theAddress:                MailRecipient;                            {  structure points into recipient and theRID. }
  175.         theRID:                    RecordID;                                {  structure points into recipient. }
  176.     END;
  177.  
  178.     SMPRecipientDescriptorPtr = ^SMPRecipientDescriptor;
  179.  
  180.     SMPEnclosureDescriptor = RECORD
  181.         next:                    ^SMPEnclosureDescriptor;
  182.         result:                    OSErr;
  183.         fileSpec:                FSSpec;
  184.         fileCreator:            OSType;                                    {  Creator of this enclosure. }
  185.         fileType:                OSType;                                    {  File Type of this enclosure. }
  186.     END;
  187.  
  188.     SMPEnclosureDescriptorPtr = ^SMPEnclosureDescriptor;
  189.  
  190.     SMPLetterPB = RECORD
  191.         result:                    OSErr;                                    { result of operation }
  192.         subject:                RStringPtr;                                { RString }
  193.         senderIdentity:            AuthIdentity;                            { Letter is sent from this Identity }
  194.         toList:                    SMPRecipientDescriptorPtr;                { Pointer to linked list }
  195.         ccList:                    SMPRecipientDescriptorPtr;                { Pointer to linked list }
  196.         bccList:                SMPRecipientDescriptorPtr;                { Pointer to linked list }
  197.         script:                    ScriptCode;                                { Identifier for language }
  198.         textSize:                Size;                                    { length of body data }
  199.         textBuffer:                Ptr;                                    { body of the letter }
  200.         sendAs:                    SMPPSendAs;                                { Send as Letter,Enclosure,Image }
  201.         padByte:                SInt8; (* Byte *)
  202.         enclosures:                SMPEnclosureDescriptorPtr;                { files to be enclosed }
  203.         drawImageProc:            SMPDrawImageUPP;                        { For imaging }
  204.         imageRefCon:            LONGINT;                                { For imaging }
  205.         supportsColor:            BOOLEAN;                                { For imaging - set to true if you application supports color imaging }
  206.         filler1:                BOOLEAN;
  207.     END;
  208.  
  209.     SMPLetterPBPtr = ^SMPLetterPB;
  210.  
  211.  
  212. CONST
  213.     kSMPAppMustHandleEventBit    = 0;
  214.     kSMPAppShouldIgnoreEventBit    = 1;
  215.     kSMPContractedBit            = 2;
  216.     kSMPExpandedBit                = 3;
  217.     kSMPMailerBecomesTargetBit    = 4;
  218.     kSMPAppBecomesTargetBit        = 5;
  219.     kSMPCursorOverMailerBit        = 6;
  220.     kSMPCreateCopyWindowBit        = 7;
  221.     kSMPDisposeCopyWindowBit    = 8;
  222.  
  223. { Values of SMPMailerResult }
  224.     kSMPAppMustHandleEventMask    = 1 * (2**(kSMPAppMustHandleEventBit));
  225.     kSMPAppShouldIgnoreEventMask = 1 * (2**(kSMPAppShouldIgnoreEventBit));
  226.     kSMPContractedMask            = 1 * (2**(kSMPContractedBit));
  227.     kSMPExpandedMask            = 1 * (2**(kSMPExpandedBit));
  228.     kSMPMailerBecomesTargetMask    = 1 * (2**(kSMPMailerBecomesTargetBit));
  229.     kSMPAppBecomesTargetMask    = 1 * (2**(kSMPAppBecomesTargetBit));
  230.     kSMPCursorOverMailerMask    = 1 * (2**(kSMPCursorOverMailerBit));
  231.     kSMPCreateCopyWindowMask    = 1 * (2**(kSMPCreateCopyWindowBit));
  232.     kSMPDisposeCopyWindowMask    = 1 * (2**(kSMPDisposeCopyWindowBit));
  233.  
  234.     
  235. TYPE
  236.     SMPMailerResult = LONGINT;
  237.  
  238. { Values of SMPMailerComponent}
  239.  
  240. CONST
  241.     kSMPOther                    = -1;
  242.     kSMPFrom                    = 32;
  243.     kSMPTo                        = 20;
  244.     kSMPRegarding                = 22;
  245.     kSMPSendDateTime            = 29;
  246.     kSMPAttachments                = 26;
  247.     kSMPAddressOMatic            = 16;
  248.  
  249.     
  250. TYPE
  251.     SMPMailerComponent = LONGINT;
  252.  
  253.  
  254. CONST
  255.     kSMPToAddress                = kMailToBit;
  256.     kSMPCCAddress                = kMailCcBit;
  257.     kSMPBCCAddress                = kMailBccBit;
  258.  
  259.     
  260. TYPE
  261.     SMPAddressType = MailAttributeID;
  262.  
  263.  
  264. CONST
  265.     kSMPUndoCommand                = 0;
  266.     kSMPCutCommand                = 1;
  267.     kSMPCopyCommand                = 2;
  268.     kSMPPasteCommand            = 3;
  269.     kSMPClearCommand            = 4;
  270.     kSMPSelectAllCommand        = 5;
  271.  
  272.     
  273. TYPE
  274.     SMPEditCommand = INTEGER;
  275.  
  276.  
  277. CONST
  278.     kSMPUndoDisabled            = 0;
  279.     kSMPAppMayUndo                = 1;
  280.     kSMPMailerUndo                = 2;
  281.  
  282.     
  283. TYPE
  284.     SMPUndoState = INTEGER;
  285.  
  286. {
  287. SMPSendFormatMask:
  288.  
  289. Bitfield indicating which combinations of formats are included in,
  290. should be included or, or can be included in a letter.
  291. }
  292.  
  293. CONST
  294.     kSMPNativeBit                = 0;
  295.     kSMPImageBit                = 1;
  296.     kSMPStandardInterchangeBit    = 2;
  297.  
  298. { Values of SMPSendFormatMask }
  299.     kSMPNativeMask                = 1 * (2**(kSMPNativeBit));
  300.     kSMPImageMask                = 1 * (2**(kSMPImageBit));
  301.     kSMPStandardInterchangeMask    = 1 * (2**(kSMPStandardInterchangeBit));
  302.  
  303.     
  304. TYPE
  305.     SMPSendFormatMask = LONGINT;
  306.  
  307. {
  308.     Pseudo-events passed to the clients filter proc for initialization and cleanup.
  309. }
  310.  
  311. CONST
  312.     kSMPSendOptionsStart        = -1;
  313.     kSMPSendOptionsEnd            = -2;
  314.  
  315. {
  316. SMPSendFormatMask:
  317.  
  318. Structure describing the format of a letter.  If kSMPNativeMask bit is set, the whichNativeFormat field indicates which of the client-defined formats to use.
  319. }
  320.  
  321. TYPE
  322.     SMPSendFormat = RECORD
  323.         whichFormats:            SMPSendFormatMask;
  324.         whichNativeFormat:        INTEGER;                                { 0 based }
  325.     END;
  326.  
  327.     SMPLetterInfo = RECORD
  328.         letterCreator:            OSType;
  329.         letterType:                OSType;
  330.         subject:                RString32;
  331.         sender:                    RString32;
  332.     END;
  333.  
  334.  
  335. CONST
  336.     kSMPSave                    = 0;
  337.     kSMPSaveAs                    = 1;
  338.     kSMPSaveACopy                = 2;
  339.  
  340.     
  341. TYPE
  342.     SMPSaveType = INTEGER;
  343.  
  344.     FrontWindowProcPtr = ProcPtr;  { FUNCTION FrontWindow(clientData: LONGINT): WindowPtr; }
  345.     PrepareMailerForDrawingProcPtr = ProcPtr;  { PROCEDURE PrepareMailerForDrawing(window: WindowPtr; clientData: LONGINT); }
  346.     SendOptionsFilterProcPtr = ProcPtr;  { FUNCTION SendOptionsFilter(theDialog: DialogPtr; VAR theEvent: EventRecord; itemHit: INTEGER; clientData: LONGINT): BOOLEAN; }
  347.     FrontWindowUPP = UniversalProcPtr;
  348.     PrepareMailerForDrawingUPP = UniversalProcPtr;
  349.     SendOptionsFilterUPP = UniversalProcPtr;
  350.  
  351. CONST
  352.     uppFrontWindowProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  353.     uppPrepareMailerForDrawingProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  354.     uppSendOptionsFilterProcInfo = $00003BD0; { FUNCTION (4 byte param, 4 byte param, 2 byte param, 4 byte param): 1 byte result; }
  355.  
  356. FUNCTION NewFrontWindowProc(userRoutine: FrontWindowProcPtr): FrontWindowUPP;
  357.     {$IFC NOT GENERATINGCFM }
  358.     INLINE $2E9F;
  359.     {$ENDC}
  360.  
  361. FUNCTION NewPrepareMailerForDrawingProc(userRoutine: PrepareMailerForDrawingProcPtr): PrepareMailerForDrawingUPP;
  362.     {$IFC NOT GENERATINGCFM }
  363.     INLINE $2E9F;
  364.     {$ENDC}
  365.  
  366. FUNCTION NewSendOptionsFilterProc(userRoutine: SendOptionsFilterProcPtr): SendOptionsFilterUPP;
  367.     {$IFC NOT GENERATINGCFM }
  368.     INLINE $2E9F;
  369.     {$ENDC}
  370.  
  371. FUNCTION CallFrontWindowProc(clientData: LONGINT; userRoutine: FrontWindowUPP): WindowPtr;
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $205F, $4E90;
  374.     {$ENDC}
  375.  
  376. PROCEDURE CallPrepareMailerForDrawingProc(window: WindowPtr; clientData: LONGINT; userRoutine: PrepareMailerForDrawingUPP);
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $205F, $4E90;
  379.     {$ENDC}
  380.  
  381. FUNCTION CallSendOptionsFilterProc(theDialog: DialogPtr; VAR theEvent: EventRecord; itemHit: INTEGER; clientData: LONGINT; userRoutine: SendOptionsFilterUPP): BOOLEAN;
  382.     {$IFC NOT GENERATINGCFM}
  383.     INLINE $205F, $4E90;
  384.     {$ENDC}
  385.  
  386. CONST
  387.     kSMPGetDimensions            = 4700;
  388.     kSMPNewMailer                = 4701;
  389.     kSMPDisposeMailer            = 4702;
  390.     kSMPMailerEvent                = 4703;
  391.     kSMPMailerEditCommand        = 4704;
  392.     kSMPMailerForward            = 4705;
  393.     kSMPMailerReply                = 4706;
  394.     kSMPGetMailerState            = 4707;
  395.     kSMPPrepareCoverPages        = 4708;
  396.     kSMPDrawNthCoverPage        = 4709;
  397.     kSMPBeginSave                = 4710;
  398.     kSMPBeginSend                = 4711;
  399.     kSMPOpenLetter                = 4712;
  400.     kSMPDrawMailer                = 4713;
  401.     kSMPMoveMailer                = 4714;
  402.     kSMPSetSubject                = 4715;
  403.     kSMPSetFromIdentity            = 4716;
  404.     kSMPAddAddress                = 4717;
  405.     kSMPAddAttachment            = 4718;
  406.     kSMPContentChanged            = 4719;
  407.     kSMPEndSave                    = 4720;
  408.     kSMPEndSend                    = 4721;
  409.     kSMPExpandOrContract        = 4722;
  410.     kSMPBecomeTarget            = 4723;
  411.     kSMPGetTabInfo                = 4724;
  412.     kSMPClearUndo                = 4725;
  413.     kSMPAttachDialog            = 4726;
  414.     kSMPGetComponentSize        = 4727;
  415.     kSMPGetComponentInfo        = 4728;
  416.     kSMPGetListItemInfo            = 4729;
  417.     kSMPAddContent                = 4730;
  418.     kSMPReadContent                = 4731;
  419.     kSMPGetFontNameFromLetter    = 4732;
  420.     kSMPAddMainEnclosure        = 4733;
  421.     kSMPGetMainEnclosureFSSpec    = 4734;
  422.     kSMPAddBlock                = 4735;
  423.     kSMPReadBlock                = 4736;
  424.     kSMPEnumerateBlocks            = 4737;
  425.     kSMPImage                    = 4738;
  426.     kSMPInitMailer                = 4741;
  427.     kSMPGetNextLetter            = 4742;
  428.     kSMPPrepareToClose            = 4743;
  429.     kSMPCloseOptionsDialog        = 4744;
  430.     kSMPPrepareToChange            = 4745;
  431.     kSMPGetLetterInfo            = 4746;
  432.     kSMPTagDialog                = 4747;
  433.     kSMPSendOptionsDialog        = 5000;
  434.  
  435.  
  436. TYPE
  437.     SMPMailerState = RECORD
  438.         mailerCount:            INTEGER;
  439.         currentMailer:            INTEGER;
  440.         upperLeft:                Point;
  441.         hasBeenReceived:        BOOLEAN;
  442.         isTarget:                BOOLEAN;
  443.         isExpanded:                BOOLEAN;
  444.         canMoveToTrash:            BOOLEAN;
  445.         canTag:                    BOOLEAN;
  446.         padByte2:                SInt8; (* Byte *)
  447.         changeCount:            LONGINT;
  448.         targetComponent:        SMPMailerComponent;
  449.         canCut:                    BOOLEAN;
  450.         canCopy:                BOOLEAN;
  451.         canPaste:                BOOLEAN;
  452.         canClear:                BOOLEAN;
  453.         canSelectAll:            BOOLEAN;
  454.         padByte3:                SInt8; (* Byte *)
  455.         undoState:                SMPUndoState;
  456.         undoWhat:                Str63;
  457.     END;
  458.  
  459.     SMPSendOptions = RECORD
  460.         signWhenSent:            BOOLEAN;
  461.         priority:                IPMPriority;
  462.     END;
  463.  
  464.     SMPSendOptionsPtr = ^SMPSendOptions;
  465.     SMPSendOptionsHandle = ^SMPSendOptionsPtr;
  466.  
  467.     SMPCloseOptions = RECORD
  468.         moveToTrash:            BOOLEAN;
  469.         addTag:                    BOOLEAN;
  470.         tag:                    RString32;
  471.     END;
  472.  
  473.     SMPCloseOptionsPtr = ^SMPCloseOptions;
  474.  
  475. {----------------------------------------------------------------------------------------
  476.     Send Package Routines
  477. ----------------------------------------------------------------------------------------}
  478.  
  479. CONST
  480.     kSMPSendLetter                = 500;
  481.     kSMPResolveToRecipient        = 1100;
  482.     kSMPNewPage                    = 2100;
  483.     kSMPImageErr                = 2101;
  484.  
  485.  
  486. FUNCTION SMPSendLetter(theLetter: SMPLetterPBPtr): OSErr;
  487.     {$IFC NOT GENERATINGCFM}
  488.     INLINE $203C, 2, 500, $AA5D;
  489.     {$ENDC}
  490. FUNCTION SMPNewPage(VAR newHeader: OpenCPicParams): OSErr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     INLINE $203C, 2, 2100, $AA5D;
  493.     {$ENDC}
  494. FUNCTION SMPImageErr: OSErr;
  495.     {$IFC NOT GENERATINGCFM}
  496.     INLINE $203C, 0, 2101, $AA5D;
  497.     {$ENDC}
  498. FUNCTION SMPResolveToRecipient(dsSpec: PackedDSSpecPtr; VAR recipientList: SMPRecipientDescriptorPtr; identity: AuthIdentity): OSErr;
  499.     {$IFC NOT GENERATINGCFM}
  500.     INLINE $203C, 6, 1100, $AA5D;
  501.     {$ENDC}
  502. FUNCTION SMPInitMailer(mailerVersion: LONGINT): OSErr;
  503.     {$IFC NOT GENERATINGCFM}
  504.     INLINE $203C, 2, 4741, $AA5D;
  505.     {$ENDC}
  506. FUNCTION SMPGetDimensions(VAR width: INTEGER; VAR contractedHeight: INTEGER; VAR expandedHeight: INTEGER): OSErr;
  507.     {$IFC NOT GENERATINGCFM}
  508.     INLINE $203C, 6, 4700, $AA5D;
  509.     {$ENDC}
  510. FUNCTION SMPGetTabInfo(VAR firstTab: SMPMailerComponent; VAR lastTab: SMPMailerComponent): OSErr;
  511.     {$IFC NOT GENERATINGCFM}
  512.     INLINE $203C, 4, 4724, $AA5D;
  513.     {$ENDC}
  514. FUNCTION SMPNewMailer(window: WindowPtr; upperLeft: Point; canContract: BOOLEAN; initiallyExpanded: BOOLEAN; identity: AuthIdentity; prepareMailerForDrawingCB: PrepareMailerForDrawingUPP; clientData: LONGINT): OSErr;
  515.     {$IFC NOT GENERATINGCFM}
  516.     INLINE $203C, 12, 4701, $AA5D;
  517.     {$ENDC}
  518. FUNCTION SMPPrepareToClose(window: WindowPtr): OSErr;
  519.     {$IFC NOT GENERATINGCFM}
  520.     INLINE $203C, 2, 4743, $AA5D;
  521.     {$ENDC}
  522. FUNCTION SMPCloseOptionsDialog(window: WindowPtr; closeOptions: SMPCloseOptionsPtr): OSErr;
  523.     {$IFC NOT GENERATINGCFM}
  524.     INLINE $203C, 4, 4744, $AA5D;
  525.     {$ENDC}
  526. FUNCTION SMPTagDialog(window: WindowPtr; VAR theTag: RString32): OSErr;
  527.     {$IFC NOT GENERATINGCFM}
  528.     INLINE $203C, 4, 4747, $AA5D;
  529.     {$ENDC}
  530. FUNCTION SMPDisposeMailer(window: WindowPtr; closeOptions: SMPCloseOptionsPtr): OSErr;
  531.     {$IFC NOT GENERATINGCFM}
  532.     INLINE $203C, 4, 4702, $AA5D;
  533.     {$ENDC}
  534. FUNCTION SMPMailerEvent({CONST}VAR event: EventRecord; VAR whatHappened: SMPMailerResult; frontWindowCB: FrontWindowUPP; clientData: LONGINT): OSErr;
  535.     {$IFC NOT GENERATINGCFM}
  536.     INLINE $203C, 8, 4703, $AA5D;
  537.     {$ENDC}
  538. FUNCTION SMPClearUndo(window: WindowPtr): OSErr;
  539.     {$IFC NOT GENERATINGCFM}
  540.     INLINE $203C, 2, 4725, $AA5D;
  541.     {$ENDC}
  542. FUNCTION SMPMailerEditCommand(window: WindowPtr; command: SMPEditCommand; VAR whatHappened: SMPMailerResult): OSErr;
  543.     {$IFC NOT GENERATINGCFM}
  544.     INLINE $203C, 5, 4704, $AA5D;
  545.     {$ENDC}
  546. FUNCTION SMPMailerForward(window: WindowPtr; from: AuthIdentity): OSErr;
  547.     {$IFC NOT GENERATINGCFM}
  548.     INLINE $203C, 4, 4705, $AA5D;
  549.     {$ENDC}
  550. FUNCTION SMPMailerReply(originalLetter: WindowPtr; newLetter: WindowPtr; replyToAll: BOOLEAN; upperLeft: Point; canContract: BOOLEAN; initiallyExpanded: BOOLEAN; identity: AuthIdentity; prepareMailerForDrawingCB: PrepareMailerForDrawingUPP; clientData: LONGINT): OSErr;
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $203C, 15, 4706, $AA5D;
  553.     {$ENDC}
  554. FUNCTION SMPGetMailerState(window: WindowPtr; VAR itsState: SMPMailerState): OSErr;
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $203C, 4, 4707, $AA5D;
  557.     {$ENDC}
  558. FUNCTION SMPSendOptionsDialog(window: WindowPtr; VAR documentName: Str255; VAR nativeFormatNames: StringPtr; nameCount: INTEGER; canSend: SMPSendFormatMask; VAR currentFormat: SMPSendFormat; filterProc: SendOptionsFilterUPP; clientData: LONGINT; VAR shouldSend: SMPSendFormat; sendOptions: SMPSendOptionsPtr): OSErr;
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $203C, 19, 5000, $AA5D;
  561.     {$ENDC}
  562. FUNCTION SMPPrepareCoverPages(window: WindowPtr; VAR pageCount: INTEGER): OSErr;
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $203C, 4, 4708, $AA5D;
  565.     {$ENDC}
  566. FUNCTION SMPDrawNthCoverPage(window: WindowPtr; pageNumber: INTEGER; doneDrawingCoverPages: BOOLEAN): OSErr;
  567.     {$IFC NOT GENERATINGCFM}
  568.     INLINE $203C, 4, 4709, $AA5D;
  569.     {$ENDC}
  570. FUNCTION SMPPrepareToChange(window: WindowPtr): OSErr;
  571.     {$IFC NOT GENERATINGCFM}
  572.     INLINE $203C, 2, 4745, $AA5D;
  573.     {$ENDC}
  574. FUNCTION SMPContentChanged(window: WindowPtr): OSErr;
  575.     {$IFC NOT GENERATINGCFM}
  576.     INLINE $203C, 2, 4719, $AA5D;
  577.     {$ENDC}
  578. FUNCTION SMPBeginSave(window: WindowPtr; {CONST}VAR diskLetter: FSSpec; creator: OSType; fileType: OSType; saveType: SMPSaveType; VAR mustAddContent: BOOLEAN): OSErr;
  579.     {$IFC NOT GENERATINGCFM}
  580.     INLINE $203C, 11, 4710, $AA5D;
  581.     {$ENDC}
  582. FUNCTION SMPEndSave(window: WindowPtr; okToSave: BOOLEAN): OSErr;
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $203C, 3, 4720, $AA5D;
  585.     {$ENDC}
  586. FUNCTION SMPBeginSend(window: WindowPtr; creator: OSType; fileType: OSType; sendOptions: SMPSendOptionsPtr; VAR mustAddContent: BOOLEAN): OSErr;
  587.     {$IFC NOT GENERATINGCFM}
  588.     INLINE $203C, 10, 4711, $AA5D;
  589.     {$ENDC}
  590. FUNCTION SMPEndSend(window: WindowPtr; okToSend: BOOLEAN): OSErr;
  591.     {$IFC NOT GENERATINGCFM}
  592.     INLINE $203C, 3, 4721, $AA5D;
  593.     {$ENDC}
  594. FUNCTION SMPOpenLetter({CONST}VAR letter: LetterDescriptor; window: WindowPtr; upperLeft: Point; canContract: BOOLEAN; initiallyExpanded: BOOLEAN; prepareMailerForDrawingCB: PrepareMailerForDrawingUPP; clientData: LONGINT): OSErr;
  595.     {$IFC NOT GENERATINGCFM}
  596.     INLINE $203C, 12, 4712, $AA5D;
  597.     {$ENDC}
  598. FUNCTION SMPAddMainEnclosure(window: WindowPtr; {CONST}VAR enclosure: FSSpec): OSErr;
  599.     {$IFC NOT GENERATINGCFM}
  600.     INLINE $203C, 4, 4733, $AA5D;
  601.     {$ENDC}
  602. FUNCTION SMPGetMainEnclosureFSSpec(window: WindowPtr; VAR enclosureDir: FSSpec): OSErr;
  603.     {$IFC NOT GENERATINGCFM}
  604.     INLINE $203C, 4, 4734, $AA5D;
  605.     {$ENDC}
  606. FUNCTION SMPAddContent(window: WindowPtr; segmentType: MailSegmentType; appendFlag: BOOLEAN; buffer: UNIV Ptr; bufferSize: LONGINT; VAR textScrap: StScrpRec; startNewScript: BOOLEAN; script: ScriptCode): OSErr;
  607.     {$IFC NOT GENERATINGCFM}
  608.     INLINE $203C, 12, 4730, $AA5D;
  609.     {$ENDC}
  610. FUNCTION SMPReadContent(window: WindowPtr; segmentTypeMask: MailSegmentMask; buffer: UNIV Ptr; bufferSize: LONGINT; VAR dataSize: LONGINT; VAR textScrap: StScrpRec; VAR script: ScriptCode; VAR segmentType: MailSegmentType; VAR endOfScript: BOOLEAN; VAR endOfSegment: BOOLEAN; VAR endOfContent: BOOLEAN; VAR segmentLength: LONGINT; VAR segmentID: LONGINT): OSErr;
  611.     {$IFC NOT GENERATINGCFM}
  612.     INLINE $203C, 25, 4731, $AA5D;
  613.     {$ENDC}
  614. FUNCTION SMPGetFontNameFromLetter(window: WindowPtr; fontNum: INTEGER; VAR fontName: Str255; doneWithFontTable: BOOLEAN): OSErr;
  615.     {$IFC NOT GENERATINGCFM}
  616.     INLINE $203C, 6, 4732, $AA5D;
  617.     {$ENDC}
  618. FUNCTION SMPAddBlock(window: WindowPtr; {CONST}VAR blockType: OCECreatorType; append: BOOLEAN; buffer: UNIV Ptr; bufferSize: LONGINT; mode: MailBlockMode; offset: LONGINT): OSErr;
  619.     {$IFC NOT GENERATINGCFM}
  620.     INLINE $203C, 12, 4735, $AA5D;
  621.     {$ENDC}
  622. FUNCTION SMPReadBlock(window: WindowPtr; {CONST}VAR blockType: OCECreatorType; blockIndex: INTEGER; buffer: UNIV Ptr; bufferSize: LONGINT; dataOffset: LONGINT; VAR dataSize: LONGINT; VAR endOfBlock: BOOLEAN; VAR remaining: LONGINT): OSErr;
  623.     {$IFC NOT GENERATINGCFM}
  624.     INLINE $203C, 17, 4736, $AA5D;
  625.     {$ENDC}
  626. FUNCTION SMPEnumerateBlocks(window: WindowPtr; startIndex: INTEGER; buffer: UNIV Ptr; bufferSize: LONGINT; VAR dataSize: LONGINT; VAR nextIndex: INTEGER; VAR more: BOOLEAN): OSErr;
  627.     {$IFC NOT GENERATINGCFM}
  628.     INLINE $203C, 13, 4737, $AA5D;
  629.     {$ENDC}
  630. FUNCTION SMPDrawMailer(window: WindowPtr): OSErr;
  631.     {$IFC NOT GENERATINGCFM}
  632.     INLINE $203C, 2, 4713, $AA5D;
  633.     {$ENDC}
  634. FUNCTION SMPSetSubject(window: WindowPtr; {CONST}VAR text: RString): OSErr;
  635.     {$IFC NOT GENERATINGCFM}
  636.     INLINE $203C, 4, 4715, $AA5D;
  637.     {$ENDC}
  638. FUNCTION SMPSetFromIdentity(window: WindowPtr; from: AuthIdentity): OSErr;
  639.     {$IFC NOT GENERATINGCFM}
  640.     INLINE $203C, 4, 4716, $AA5D;
  641.     {$ENDC}
  642. FUNCTION SMPAddAddress(window: WindowPtr; addrType: SMPAddressType; VAR address: OCEPackedRecipient): OSErr;
  643.     {$IFC NOT GENERATINGCFM}
  644.     INLINE $203C, 5, 4717, $AA5D;
  645.     {$ENDC}
  646. FUNCTION SMPAddAttachment(window: WindowPtr; {CONST}VAR attachment: FSSpec): OSErr;
  647.     {$IFC NOT GENERATINGCFM}
  648.     INLINE $203C, 4, 4718, $AA5D;
  649.     {$ENDC}
  650. FUNCTION SMPAttachDialog(window: WindowPtr): OSErr;
  651.     {$IFC NOT GENERATINGCFM}
  652.     INLINE $203C, 2, 4726, $AA5D;
  653.     {$ENDC}
  654. FUNCTION SMPExpandOrContract(window: WindowPtr; expand: BOOLEAN): OSErr;
  655.     {$IFC NOT GENERATINGCFM}
  656.     INLINE $203C, 3, 4722, $AA5D;
  657.     {$ENDC}
  658. FUNCTION SMPMoveMailer(window: WindowPtr; dh: INTEGER; dv: INTEGER): OSErr;
  659.     {$IFC NOT GENERATINGCFM}
  660.     INLINE $203C, 4, 4714, $AA5D;
  661.     {$ENDC}
  662. FUNCTION SMPBecomeTarget(window: WindowPtr; becomeTarget: BOOLEAN; whichField: SMPMailerComponent): OSErr;
  663.     {$IFC NOT GENERATINGCFM}
  664.     INLINE $203C, 5, 4723, $AA5D;
  665.     {$ENDC}
  666. FUNCTION SMPGetComponentSize(window: WindowPtr; whichMailer: INTEGER; whichField: SMPMailerComponent; VAR size: INTEGER): OSErr;
  667.     {$IFC NOT GENERATINGCFM}
  668.     INLINE $203C, 7, 4727, $AA5D;
  669.     {$ENDC}
  670. FUNCTION SMPGetComponentInfo(window: WindowPtr; whichMailer: INTEGER; whichField: SMPMailerComponent; buffer: UNIV Ptr): OSErr;
  671.     {$IFC NOT GENERATINGCFM}
  672.     INLINE $203C, 7, 4728, $AA5D;
  673.     {$ENDC}
  674. FUNCTION SMPGetListItemInfo(window: WindowPtr; whichMailer: INTEGER; whichField: SMPMailerComponent; buffer: UNIV Ptr; bufferLength: LONGINT; startItem: INTEGER; VAR itemCount: INTEGER; VAR nextItem: INTEGER; VAR more: BOOLEAN): OSErr;
  675.     {$IFC NOT GENERATINGCFM}
  676.     INLINE $203C, 16, 4729, $AA5D;
  677.     {$ENDC}
  678. FUNCTION SMPImage(window: WindowPtr; drawImageProc: SMPDrawImageUPP; imageRefCon: LONGINT; supportsColor: BOOLEAN): OSErr;
  679.     {$IFC NOT GENERATINGCFM}
  680.     INLINE $203C, 7, 4738, $AA5D;
  681.     {$ENDC}
  682. FUNCTION SMPGetNextLetter(VAR typesList: OSType; numTypes: INTEGER; VAR adjacentLetter: LetterDescriptor): OSErr;
  683.     {$IFC NOT GENERATINGCFM}
  684.     INLINE $203C, 5, 4742, $AA5D;
  685.     {$ENDC}
  686. FUNCTION SMPGetLetterInfo(VAR mailboxSpec: LetterSpec; VAR info: SMPLetterInfo): OSErr;
  687.     {$IFC NOT GENERATINGCFM}
  688.     INLINE $203C, 4, 4746, $AA5D;
  689.     {$ENDC}
  690.  
  691. {$ALIGN RESET}
  692. {$POP}
  693.  
  694. {$SETC UsingIncludes := OCEStandardMailIncludes}
  695.  
  696. {$ENDC} {__OCESTANDARDMAIL__}
  697.  
  698. {$IFC NOT UsingIncludes}
  699.  END.
  700. {$ENDC}
  701.